/*
* MATLAB Compiler: 4.18.1 (R2013a)
* Date: Fri May 24 04:57:45 2013
* Arguments: "-B" "macro_default" "-W" "dotnet:Ploter,Ploter,0.0,private" "-T" "link:lib"
* "-d" "C:\Users\leniwin\Documents\MATLAB\NET\Ploter\src" "-w"
* "enable:specified_file_mismatch" "-w" "enable:repeated_file" "-w"
* "enable:switch_ignored" "-w" "enable:missing_lib_sentinel" "-w" "enable:demo_license"
* "-v"
* "class{Ploter:C:\Users\leniwin\Documents\MATLAB\AxesDim.m,C:\Users\leniwin\Documents\MAT
* LAB\ChangeAxes.m,C:\Users\leniwin\Documents\MATLAB\ClearAxes.m,C:\Users\leniwin\Document
* s\MATLAB\CloseFigure.m,C:\Users\leniwin\Documents\MATLAB\FindStreetPosition.m,C:\Users\l
* eniwin\Documents\MATLAB\FindTLPosition.m,C:\Users\leniwin\Documents\MATLAB\HeatScale.m,C
* :\Users\leniwin\Documents\MATLAB\OpenFigure.m,C:\Users\leniwin\Documents\MATLAB\PlotCar.
* m,C:\Users\leniwin\Documents\MATLAB\PlotCircle1.m,C:\Users\leniwin\Documents\MATLAB\Plot
* Circle2.m,C:\Users\leniwin\Documents\MATLAB\PlotIteration.m,C:\Users\leniwin\Documents\M
* ATLAB\PlotLine.m,C:\Users\leniwin\Documents\MATLAB\PlotNameCircle.m,C:\Users\leniwin\Doc
* uments\MATLAB\PlotTraficLight.m}" "-a"
* "C:\Users\leniwin\Documents\MATLAB\TrafficLight.ico" 
*/
using System;
using System.Reflection;
using System.IO;
using MathWorks.MATLAB.NET.Arrays;
using MathWorks.MATLAB.NET.Utility;

#if SHARED
[assembly: System.Reflection.AssemblyKeyFile(@"")]
#endif

namespace Ploter
{

  /// <summary>
  /// The Ploter class provides a CLS compliant, MWArray interface to the MATLAB
  /// functions contained in the files:
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\AxesDim.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\ChangeAxes.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\ClearAxes.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\CloseFigure.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\FindStreetPosition.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\FindTLPosition.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\HeatScale.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\OpenFigure.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\PlotCar.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\PlotCircle1.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\PlotCircle2.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\PlotIteration.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\PlotLine.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\PlotNameCircle.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\PlotTraficLight.m
  /// <newpara></newpara>
  /// deployprint.m
  /// <newpara></newpara>
  /// printdlg.m
  /// </summary>
  /// <remarks>
  /// @Version 0.0
  /// </remarks>
  public class Ploter : IDisposable
  {
    #region Constructors

    /// <summary internal= "true">
    /// The static constructor instantiates and initializes the MATLAB Compiler Runtime
    /// instance.
    /// </summary>
    static Ploter()
    {
      if (MWMCR.MCRAppInitialized)
      {
        try
        {
          Assembly assembly= Assembly.GetExecutingAssembly();

          string ctfFilePath= assembly.Location;

          int lastDelimiter= ctfFilePath.LastIndexOf(@"\");

          ctfFilePath= ctfFilePath.Remove(lastDelimiter, (ctfFilePath.Length - lastDelimiter));

          string ctfFileName = "Ploter.ctf";

          Stream embeddedCtfStream = null;

          String[] resourceStrings = assembly.GetManifestResourceNames();

          foreach (String name in resourceStrings)
          {
            if (name.Contains(ctfFileName))
            {
              embeddedCtfStream = assembly.GetManifestResourceStream(name);
              break;
            }
          }
          mcr= new MWMCR("",
                         ctfFilePath, embeddedCtfStream, true);
        }
        catch(Exception ex)
        {
          ex_ = new Exception("MWArray assembly failed to be initialized", ex);
        }
      }
      else
      {
        ex_ = new ApplicationException("MWArray assembly could not be initialized");
      }
    }


    /// <summary>
    /// Constructs a new instance of the Ploter class.
    /// </summary>
    public Ploter()
    {
      if(ex_ != null)
      {
        throw ex_;
      }
    }


    #endregion Constructors

    #region Finalize

    /// <summary internal= "true">
    /// Class destructor called by the CLR garbage collector.
    /// </summary>
    ~Ploter()
    {
      Dispose(false);
    }


    /// <summary>
    /// Frees the native resources associated with this object
    /// </summary>
    public void Dispose()
    {
      Dispose(true);

      GC.SuppressFinalize(this);
    }


    /// <summary internal= "true">
    /// Internal dispose function
    /// </summary>
    protected virtual void Dispose(bool disposing)
    {
      if (!disposed)
      {
        disposed= true;

        if (disposing)
        {
          // Free managed resources;
        }

        // Free native resources
      }
    }


    #endregion Finalize

    #region Methods

    /// <summary>
    /// Provides a void output, 0-input MWArrayinterface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void AxesDim()
    {
      mcr.EvaluateFunction(0, "AxesDim", new MWArray[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input MWArrayinterface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    ///
    public void AxesDim(MWArray axeshandle)
    {
      mcr.EvaluateFunction(0, "AxesDim", axeshandle);
    }


    /// <summary>
    /// Provides a void output, 2-input MWArrayinterface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="minx">Input argument #2</param>
    ///
    public void AxesDim(MWArray axeshandle, MWArray minx)
    {
      mcr.EvaluateFunction(0, "AxesDim", axeshandle, minx);
    }


    /// <summary>
    /// Provides a void output, 3-input MWArrayinterface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="minx">Input argument #2</param>
    /// <param name="maxx">Input argument #3</param>
    ///
    public void AxesDim(MWArray axeshandle, MWArray minx, MWArray maxx)
    {
      mcr.EvaluateFunction(0, "AxesDim", axeshandle, minx, maxx);
    }


    /// <summary>
    /// Provides a void output, 4-input MWArrayinterface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="minx">Input argument #2</param>
    /// <param name="maxx">Input argument #3</param>
    /// <param name="miny">Input argument #4</param>
    ///
    public void AxesDim(MWArray axeshandle, MWArray minx, MWArray maxx, MWArray miny)
    {
      mcr.EvaluateFunction(0, "AxesDim", axeshandle, minx, maxx, miny);
    }


    /// <summary>
    /// Provides a void output, 5-input MWArrayinterface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="minx">Input argument #2</param>
    /// <param name="maxx">Input argument #3</param>
    /// <param name="miny">Input argument #4</param>
    /// <param name="maxy">Input argument #5</param>
    ///
    public void AxesDim(MWArray axeshandle, MWArray minx, MWArray maxx, MWArray miny, 
                  MWArray maxy)
    {
      mcr.EvaluateFunction(0, "AxesDim", axeshandle, minx, maxx, miny, maxy);
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] AxesDim(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "AxesDim", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] AxesDim(int numArgsOut, MWArray axeshandle)
    {
      return mcr.EvaluateFunction(numArgsOut, "AxesDim", axeshandle);
    }


    /// <summary>
    /// Provides the standard 2-input MWArray interface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="minx">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] AxesDim(int numArgsOut, MWArray axeshandle, MWArray minx)
    {
      return mcr.EvaluateFunction(numArgsOut, "AxesDim", axeshandle, minx);
    }


    /// <summary>
    /// Provides the standard 3-input MWArray interface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="minx">Input argument #2</param>
    /// <param name="maxx">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] AxesDim(int numArgsOut, MWArray axeshandle, MWArray minx, MWArray 
                       maxx)
    {
      return mcr.EvaluateFunction(numArgsOut, "AxesDim", axeshandle, minx, maxx);
    }


    /// <summary>
    /// Provides the standard 4-input MWArray interface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="minx">Input argument #2</param>
    /// <param name="maxx">Input argument #3</param>
    /// <param name="miny">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] AxesDim(int numArgsOut, MWArray axeshandle, MWArray minx, MWArray 
                       maxx, MWArray miny)
    {
      return mcr.EvaluateFunction(numArgsOut, "AxesDim", axeshandle, minx, maxx, miny);
    }


    /// <summary>
    /// Provides the standard 5-input MWArray interface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="minx">Input argument #2</param>
    /// <param name="maxx">Input argument #3</param>
    /// <param name="miny">Input argument #4</param>
    /// <param name="maxy">Input argument #5</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] AxesDim(int numArgsOut, MWArray axeshandle, MWArray minx, MWArray 
                       maxx, MWArray miny, MWArray maxy)
    {
      return mcr.EvaluateFunction(numArgsOut, "AxesDim", axeshandle, minx, maxx, miny, maxy);
    }


    /// <summary>
    /// Provides a void output, 0-input MWArrayinterface to the ChangeAxes MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void ChangeAxes()
    {
      mcr.EvaluateFunction(0, "ChangeAxes", new MWArray[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input MWArrayinterface to the ChangeAxes MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    ///
    public void ChangeAxes(MWArray axeshandle)
    {
      mcr.EvaluateFunction(0, "ChangeAxes", axeshandle);
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the ChangeAxes MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] ChangeAxes(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "ChangeAxes", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the ChangeAxes MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] ChangeAxes(int numArgsOut, MWArray axeshandle)
    {
      return mcr.EvaluateFunction(numArgsOut, "ChangeAxes", axeshandle);
    }


    /// <summary>
    /// Provides a void output, 0-input MWArrayinterface to the ClearAxes MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void ClearAxes()
    {
      mcr.EvaluateFunction(0, "ClearAxes", new MWArray[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input MWArrayinterface to the ClearAxes MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    ///
    public void ClearAxes(MWArray axeshandle)
    {
      mcr.EvaluateFunction(0, "ClearAxes", axeshandle);
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the ClearAxes MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] ClearAxes(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "ClearAxes", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the ClearAxes MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] ClearAxes(int numArgsOut, MWArray axeshandle)
    {
      return mcr.EvaluateFunction(numArgsOut, "ClearAxes", axeshandle);
    }


    /// <summary>
    /// Provides a void output, 0-input MWArrayinterface to the CloseFigure MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void CloseFigure()
    {
      mcr.EvaluateFunction(0, "CloseFigure", new MWArray[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input MWArrayinterface to the CloseFigure MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    ///
    public void CloseFigure(MWArray axeshandle)
    {
      mcr.EvaluateFunction(0, "CloseFigure", axeshandle);
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the CloseFigure MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] CloseFigure(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "CloseFigure", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the CloseFigure MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] CloseFigure(int numArgsOut, MWArray axeshandle)
    {
      return mcr.EvaluateFunction(numArgsOut, "CloseFigure", axeshandle);
    }


    /// <summary>
    /// Provides a single output, 0-input MWArrayinterface to the FindStreetPosition
    /// MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray FindStreetPosition()
    {
      return mcr.EvaluateFunction("FindStreetPosition", new MWArray[]{});
    }


    /// <summary>
    /// Provides a single output, 1-input MWArrayinterface to the FindStreetPosition
    /// MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray FindStreetPosition(MWArray pos1x)
    {
      return mcr.EvaluateFunction("FindStreetPosition", pos1x);
    }


    /// <summary>
    /// Provides a single output, 2-input MWArrayinterface to the FindStreetPosition
    /// MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray FindStreetPosition(MWArray pos1x, MWArray pos1y)
    {
      return mcr.EvaluateFunction("FindStreetPosition", pos1x, pos1y);
    }


    /// <summary>
    /// Provides a single output, 3-input MWArrayinterface to the FindStreetPosition
    /// MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray FindStreetPosition(MWArray pos1x, MWArray pos1y, MWArray pos2x)
    {
      return mcr.EvaluateFunction("FindStreetPosition", pos1x, pos1y, pos2x);
    }


    /// <summary>
    /// Provides a single output, 4-input MWArrayinterface to the FindStreetPosition
    /// MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <param name="pos2y">Input argument #4</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray FindStreetPosition(MWArray pos1x, MWArray pos1y, MWArray pos2x, 
                                MWArray pos2y)
    {
      return mcr.EvaluateFunction("FindStreetPosition", pos1x, pos1y, pos2x, pos2y);
    }


    /// <summary>
    /// Provides a single output, 5-input MWArrayinterface to the FindStreetPosition
    /// MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <param name="pos2y">Input argument #4</param>
    /// <param name="radius">Input argument #5</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray FindStreetPosition(MWArray pos1x, MWArray pos1y, MWArray pos2x, 
                                MWArray pos2y, MWArray radius)
    {
      return mcr.EvaluateFunction("FindStreetPosition", pos1x, pos1y, pos2x, pos2y, radius);
    }


    /// <summary>
    /// Provides a single output, 6-input MWArrayinterface to the FindStreetPosition
    /// MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <param name="pos2y">Input argument #4</param>
    /// <param name="radius">Input argument #5</param>
    /// <param name="angle">Input argument #6</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray FindStreetPosition(MWArray pos1x, MWArray pos1y, MWArray pos2x, 
                                MWArray pos2y, MWArray radius, MWArray angle)
    {
      return mcr.EvaluateFunction("FindStreetPosition", pos1x, pos1y, pos2x, pos2y, radius, angle);
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the FindStreetPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] FindStreetPosition(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindStreetPosition", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the FindStreetPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] FindStreetPosition(int numArgsOut, MWArray pos1x)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindStreetPosition", pos1x);
    }


    /// <summary>
    /// Provides the standard 2-input MWArray interface to the FindStreetPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] FindStreetPosition(int numArgsOut, MWArray pos1x, MWArray pos1y)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindStreetPosition", pos1x, pos1y);
    }


    /// <summary>
    /// Provides the standard 3-input MWArray interface to the FindStreetPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] FindStreetPosition(int numArgsOut, MWArray pos1x, MWArray pos1y, 
                                  MWArray pos2x)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindStreetPosition", pos1x, pos1y, pos2x);
    }


    /// <summary>
    /// Provides the standard 4-input MWArray interface to the FindStreetPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <param name="pos2y">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] FindStreetPosition(int numArgsOut, MWArray pos1x, MWArray pos1y, 
                                  MWArray pos2x, MWArray pos2y)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindStreetPosition", pos1x, pos1y, pos2x, pos2y);
    }


    /// <summary>
    /// Provides the standard 5-input MWArray interface to the FindStreetPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <param name="pos2y">Input argument #4</param>
    /// <param name="radius">Input argument #5</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] FindStreetPosition(int numArgsOut, MWArray pos1x, MWArray pos1y, 
                                  MWArray pos2x, MWArray pos2y, MWArray radius)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindStreetPosition", pos1x, pos1y, pos2x, pos2y, radius);
    }


    /// <summary>
    /// Provides the standard 6-input MWArray interface to the FindStreetPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <param name="pos2y">Input argument #4</param>
    /// <param name="radius">Input argument #5</param>
    /// <param name="angle">Input argument #6</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] FindStreetPosition(int numArgsOut, MWArray pos1x, MWArray pos1y, 
                                  MWArray pos2x, MWArray pos2y, MWArray radius, MWArray 
                                  angle)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindStreetPosition", pos1x, pos1y, pos2x, pos2y, radius, angle);
    }


    /// <summary>
    /// Provides an interface for the FindStreetPosition function in which the input and
    /// output
    /// arguments are specified as an array of MWArrays.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of MWArray output arguments</param>
    /// <param name= "argsIn">Array of MWArray input arguments</param>
    ///
    public void FindStreetPosition(int numArgsOut, ref MWArray[] argsOut, MWArray[] 
                         argsIn)
    {
      mcr.EvaluateFunction("FindStreetPosition", numArgsOut, ref argsOut, argsIn);
    }


    /// <summary>
    /// Provides a single output, 0-input MWArrayinterface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray FindTLPosition()
    {
      return mcr.EvaluateFunction("FindTLPosition", new MWArray[]{});
    }


    /// <summary>
    /// Provides a single output, 1-input MWArrayinterface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray FindTLPosition(MWArray pos1x)
    {
      return mcr.EvaluateFunction("FindTLPosition", pos1x);
    }


    /// <summary>
    /// Provides a single output, 2-input MWArrayinterface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray FindTLPosition(MWArray pos1x, MWArray pos1y)
    {
      return mcr.EvaluateFunction("FindTLPosition", pos1x, pos1y);
    }


    /// <summary>
    /// Provides a single output, 3-input MWArrayinterface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray FindTLPosition(MWArray pos1x, MWArray pos1y, MWArray pos2x)
    {
      return mcr.EvaluateFunction("FindTLPosition", pos1x, pos1y, pos2x);
    }


    /// <summary>
    /// Provides a single output, 4-input MWArrayinterface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <param name="pos2y">Input argument #4</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray FindTLPosition(MWArray pos1x, MWArray pos1y, MWArray pos2x, MWArray 
                            pos2y)
    {
      return mcr.EvaluateFunction("FindTLPosition", pos1x, pos1y, pos2x, pos2y);
    }


    /// <summary>
    /// Provides a single output, 5-input MWArrayinterface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <param name="pos2y">Input argument #4</param>
    /// <param name="radius">Input argument #5</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray FindTLPosition(MWArray pos1x, MWArray pos1y, MWArray pos2x, MWArray 
                            pos2y, MWArray radius)
    {
      return mcr.EvaluateFunction("FindTLPosition", pos1x, pos1y, pos2x, pos2y, radius);
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] FindTLPosition(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindTLPosition", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] FindTLPosition(int numArgsOut, MWArray pos1x)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindTLPosition", pos1x);
    }


    /// <summary>
    /// Provides the standard 2-input MWArray interface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] FindTLPosition(int numArgsOut, MWArray pos1x, MWArray pos1y)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindTLPosition", pos1x, pos1y);
    }


    /// <summary>
    /// Provides the standard 3-input MWArray interface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] FindTLPosition(int numArgsOut, MWArray pos1x, MWArray pos1y, MWArray 
                              pos2x)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindTLPosition", pos1x, pos1y, pos2x);
    }


    /// <summary>
    /// Provides the standard 4-input MWArray interface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <param name="pos2y">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] FindTLPosition(int numArgsOut, MWArray pos1x, MWArray pos1y, MWArray 
                              pos2x, MWArray pos2y)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindTLPosition", pos1x, pos1y, pos2x, pos2y);
    }


    /// <summary>
    /// Provides the standard 5-input MWArray interface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <param name="pos2y">Input argument #4</param>
    /// <param name="radius">Input argument #5</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] FindTLPosition(int numArgsOut, MWArray pos1x, MWArray pos1y, MWArray 
                              pos2x, MWArray pos2y, MWArray radius)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindTLPosition", pos1x, pos1y, pos2x, pos2y, radius);
    }


    /// <summary>
    /// Provides an interface for the FindTLPosition function in which the input and
    /// output
    /// arguments are specified as an array of MWArrays.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of MWArray output arguments</param>
    /// <param name= "argsIn">Array of MWArray input arguments</param>
    ///
    public void FindTLPosition(int numArgsOut, ref MWArray[] argsOut, MWArray[] argsIn)
    {
      mcr.EvaluateFunction("FindTLPosition", numArgsOut, ref argsOut, argsIn);
    }


    /// <summary>
    /// Provides a void output, 0-input MWArrayinterface to the HeatScale MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void HeatScale()
    {
      mcr.EvaluateFunction(0, "HeatScale", new MWArray[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input MWArrayinterface to the HeatScale MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    ///
    public void HeatScale(MWArray axeshandle)
    {
      mcr.EvaluateFunction(0, "HeatScale", axeshandle);
    }


    /// <summary>
    /// Provides a void output, 2-input MWArrayinterface to the HeatScale MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    ///
    public void HeatScale(MWArray axeshandle, MWArray posx)
    {
      mcr.EvaluateFunction(0, "HeatScale", axeshandle, posx);
    }


    /// <summary>
    /// Provides a void output, 3-input MWArrayinterface to the HeatScale MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <param name="posy">Input argument #3</param>
    ///
    public void HeatScale(MWArray axeshandle, MWArray posx, MWArray posy)
    {
      mcr.EvaluateFunction(0, "HeatScale", axeshandle, posx, posy);
    }


    /// <summary>
    /// Provides a void output, 4-input MWArrayinterface to the HeatScale MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <param name="posy">Input argument #3</param>
    /// <param name="width">Input argument #4</param>
    ///
    public void HeatScale(MWArray axeshandle, MWArray posx, MWArray posy, MWArray width)
    {
      mcr.EvaluateFunction(0, "HeatScale", axeshandle, posx, posy, width);
    }


    /// <summary>
    /// Provides a void output, 5-input MWArrayinterface to the HeatScale MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <param name="posy">Input argument #3</param>
    /// <param name="width">Input argument #4</param>
    /// <param name="height">Input argument #5</param>
    ///
    public void HeatScale(MWArray axeshandle, MWArray posx, MWArray posy, MWArray width, 
                    MWArray height)
    {
      mcr.EvaluateFunction(0, "HeatScale", axeshandle, posx, posy, width, height);
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the HeatScale MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] HeatScale(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "HeatScale", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the HeatScale MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] HeatScale(int numArgsOut, MWArray axeshandle)
    {
      return mcr.EvaluateFunction(numArgsOut, "HeatScale", axeshandle);
    }


    /// <summary>
    /// Provides the standard 2-input MWArray interface to the HeatScale MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] HeatScale(int numArgsOut, MWArray axeshandle, MWArray posx)
    {
      return mcr.EvaluateFunction(numArgsOut, "HeatScale", axeshandle, posx);
    }


    /// <summary>
    /// Provides the standard 3-input MWArray interface to the HeatScale MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <param name="posy">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] HeatScale(int numArgsOut, MWArray axeshandle, MWArray posx, MWArray 
                         posy)
    {
      return mcr.EvaluateFunction(numArgsOut, "HeatScale", axeshandle, posx, posy);
    }


    /// <summary>
    /// Provides the standard 4-input MWArray interface to the HeatScale MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <param name="posy">Input argument #3</param>
    /// <param name="width">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] HeatScale(int numArgsOut, MWArray axeshandle, MWArray posx, MWArray 
                         posy, MWArray width)
    {
      return mcr.EvaluateFunction(numArgsOut, "HeatScale", axeshandle, posx, posy, width);
    }


    /// <summary>
    /// Provides the standard 5-input MWArray interface to the HeatScale MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <param name="posy">Input argument #3</param>
    /// <param name="width">Input argument #4</param>
    /// <param name="height">Input argument #5</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] HeatScale(int numArgsOut, MWArray axeshandle, MWArray posx, MWArray 
                         posy, MWArray width, MWArray height)
    {
      return mcr.EvaluateFunction(numArgsOut, "HeatScale", axeshandle, posx, posy, width, height);
    }


    /// <summary>
    /// Provides a single output, 0-input MWArrayinterface to the OpenFigure MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// jFrame=get(fighandle,'javaframe');
    /// jIcon=javax.swing.ImageIcon('TrafficLight.ico');
    /// jFrame.setFigureIcon(jIcon);
    /// </remarks>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray OpenFigure()
    {
      return mcr.EvaluateFunction("OpenFigure", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the OpenFigure MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// jFrame=get(fighandle,'javaframe');
    /// jIcon=javax.swing.ImageIcon('TrafficLight.ico');
    /// jFrame.setFigureIcon(jIcon);
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] OpenFigure(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "OpenFigure", new MWArray[]{});
    }


    /// <summary>
    /// Provides an interface for the OpenFigure function in which the input and output
    /// arguments are specified as an array of MWArrays.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// M-Documentation:
    /// jFrame=get(fighandle,'javaframe');
    /// jIcon=javax.swing.ImageIcon('TrafficLight.ico');
    /// jFrame.setFigureIcon(jIcon);
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of MWArray output arguments</param>
    /// <param name= "argsIn">Array of MWArray input arguments</param>
    ///
    public void OpenFigure(int numArgsOut, ref MWArray[] argsOut, MWArray[] argsIn)
    {
      mcr.EvaluateFunction("OpenFigure", numArgsOut, ref argsOut, argsIn);
    }


    /// <summary>
    /// Provides a void output, 0-input MWArrayinterface to the PlotCar MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void PlotCar()
    {
      mcr.EvaluateFunction(0, "PlotCar", new MWArray[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input MWArrayinterface to the PlotCar MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="varargin">Array of MWArrays representing the input arguments 1
    /// through varargin.length</param>
    ///
    public void PlotCar(params MWArray[] varargin)
    {
      mcr.EvaluateFunction(0, "PlotCar", varargin);
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the PlotCar MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotCar(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCar", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the PlotCar MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="varargin">Array of MWArrays representing the input arguments 1
    /// through varargin.length</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotCar(int numArgsOut, params MWArray[] varargin)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCar", varargin);
    }


    /// <summary>
    /// Provides a void output, 0-input MWArrayinterface to the PlotCircle1 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void PlotCircle1()
    {
      mcr.EvaluateFunction(0, "PlotCircle1", new MWArray[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input MWArrayinterface to the PlotCircle1 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx">Input argument #1</param>
    ///
    public void PlotCircle1(MWArray posx)
    {
      mcr.EvaluateFunction(0, "PlotCircle1", posx);
    }


    /// <summary>
    /// Provides a void output, 2-input MWArrayinterface to the PlotCircle1 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    ///
    public void PlotCircle1(MWArray posx, MWArray posy)
    {
      mcr.EvaluateFunction(0, "PlotCircle1", posx, posy);
    }


    /// <summary>
    /// Provides a void output, 3-input MWArrayinterface to the PlotCircle1 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <param name="radius">Input argument #3</param>
    ///
    public void PlotCircle1(MWArray posx, MWArray posy, MWArray radius)
    {
      mcr.EvaluateFunction(0, "PlotCircle1", posx, posy, radius);
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the PlotCircle1 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotCircle1(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCircle1", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the PlotCircle1 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotCircle1(int numArgsOut, MWArray posx)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCircle1", posx);
    }


    /// <summary>
    /// Provides the standard 2-input MWArray interface to the PlotCircle1 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotCircle1(int numArgsOut, MWArray posx, MWArray posy)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCircle1", posx, posy);
    }


    /// <summary>
    /// Provides the standard 3-input MWArray interface to the PlotCircle1 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <param name="radius">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotCircle1(int numArgsOut, MWArray posx, MWArray posy, MWArray 
                           radius)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCircle1", posx, posy, radius);
    }


    /// <summary>
    /// Provides a void output, 0-input MWArrayinterface to the PlotCircle2 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void PlotCircle2()
    {
      mcr.EvaluateFunction(0, "PlotCircle2", new MWArray[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input MWArrayinterface to the PlotCircle2 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx">Input argument #1</param>
    ///
    public void PlotCircle2(MWArray posx)
    {
      mcr.EvaluateFunction(0, "PlotCircle2", posx);
    }


    /// <summary>
    /// Provides a void output, 2-input MWArrayinterface to the PlotCircle2 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    ///
    public void PlotCircle2(MWArray posx, MWArray posy)
    {
      mcr.EvaluateFunction(0, "PlotCircle2", posx, posy);
    }


    /// <summary>
    /// Provides a void output, 3-input MWArrayinterface to the PlotCircle2 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <param name="radius">Input argument #3</param>
    ///
    public void PlotCircle2(MWArray posx, MWArray posy, MWArray radius)
    {
      mcr.EvaluateFunction(0, "PlotCircle2", posx, posy, radius);
    }


    /// <summary>
    /// Provides a void output, 4-input MWArrayinterface to the PlotCircle2 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <param name="radius">Input argument #3</param>
    /// <param name="szazalek">Input argument #4</param>
    ///
    public void PlotCircle2(MWArray posx, MWArray posy, MWArray radius, MWArray szazalek)
    {
      mcr.EvaluateFunction(0, "PlotCircle2", posx, posy, radius, szazalek);
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the PlotCircle2 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotCircle2(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCircle2", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the PlotCircle2 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotCircle2(int numArgsOut, MWArray posx)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCircle2", posx);
    }


    /// <summary>
    /// Provides the standard 2-input MWArray interface to the PlotCircle2 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotCircle2(int numArgsOut, MWArray posx, MWArray posy)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCircle2", posx, posy);
    }


    /// <summary>
    /// Provides the standard 3-input MWArray interface to the PlotCircle2 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <param name="radius">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotCircle2(int numArgsOut, MWArray posx, MWArray posy, MWArray 
                           radius)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCircle2", posx, posy, radius);
    }


    /// <summary>
    /// Provides the standard 4-input MWArray interface to the PlotCircle2 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <param name="radius">Input argument #3</param>
    /// <param name="szazalek">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotCircle2(int numArgsOut, MWArray posx, MWArray posy, MWArray 
                           radius, MWArray szazalek)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCircle2", posx, posy, radius, szazalek);
    }


    /// <summary>
    /// Provides a void output, 0-input MWArrayinterface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void PlotIteration()
    {
      mcr.EvaluateFunction(0, "PlotIteration", new MWArray[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input MWArrayinterface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axes1">Input argument #1</param>
    ///
    public void PlotIteration(MWArray axes1)
    {
      mcr.EvaluateFunction(0, "PlotIteration", axes1);
    }


    /// <summary>
    /// Provides a void output, 2-input MWArrayinterface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axes1">Input argument #1</param>
    /// <param name="axes2">Input argument #2</param>
    ///
    public void PlotIteration(MWArray axes1, MWArray axes2)
    {
      mcr.EvaluateFunction(0, "PlotIteration", axes1, axes2);
    }


    /// <summary>
    /// Provides a void output, 3-input MWArrayinterface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axes1">Input argument #1</param>
    /// <param name="axes2">Input argument #2</param>
    /// <param name="db1">Input argument #3</param>
    ///
    public void PlotIteration(MWArray axes1, MWArray axes2, MWArray db1)
    {
      mcr.EvaluateFunction(0, "PlotIteration", axes1, axes2, db1);
    }


    /// <summary>
    /// Provides a void output, 4-input MWArrayinterface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axes1">Input argument #1</param>
    /// <param name="axes2">Input argument #2</param>
    /// <param name="db1">Input argument #3</param>
    /// <param name="db2">Input argument #4</param>
    ///
    public void PlotIteration(MWArray axes1, MWArray axes2, MWArray db1, MWArray db2)
    {
      mcr.EvaluateFunction(0, "PlotIteration", axes1, axes2, db1, db2);
    }


    /// <summary>
    /// Provides a void output, 5-input MWArrayinterface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axes1">Input argument #1</param>
    /// <param name="axes2">Input argument #2</param>
    /// <param name="db1">Input argument #3</param>
    /// <param name="db2">Input argument #4</param>
    /// <param name="radius">Input argument #5</param>
    ///
    public void PlotIteration(MWArray axes1, MWArray axes2, MWArray db1, MWArray db2, 
                        MWArray radius)
    {
      mcr.EvaluateFunction(0, "PlotIteration", axes1, axes2, db1, db2, radius);
    }


    /// <summary>
    /// Provides a void output, 6-input MWArrayinterface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axes1">Input argument #1</param>
    /// <param name="axes2">Input argument #2</param>
    /// <param name="db1">Input argument #3</param>
    /// <param name="db2">Input argument #4</param>
    /// <param name="radius">Input argument #5</param>
    /// <param name="varargin">Array of MWArrays representing the input arguments 6
    /// through varargin.length+5</param>
    ///
    public void PlotIteration(MWArray axes1, MWArray axes2, MWArray db1, MWArray db2, 
                        MWArray radius, params MWArray[] varargin)
    {
      MWArray[] args = {axes1, axes2, db1, db2, radius};
      int nonVarargInputNum = args.Length;
      int varargInputNum = varargin.Length;
      int totalNumArgs = varargInputNum > 0 ? (nonVarargInputNum + varargInputNum) : nonVarargInputNum;
      Array newArr = Array.CreateInstance(typeof(MWArray), totalNumArgs);

      int idx = 0;

      for (idx = 0; idx < nonVarargInputNum; idx++)
        newArr.SetValue(args[idx],idx);

      if (varargInputNum > 0)
      {
        for (int i = 0; i < varargInputNum; i++)
        {
          newArr.SetValue(varargin[i], idx);
          idx++;
        }
      }

      mcr.EvaluateFunction(0, "PlotIteration", (MWArray[])newArr );
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotIteration(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotIteration", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axes1">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotIteration(int numArgsOut, MWArray axes1)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotIteration", axes1);
    }


    /// <summary>
    /// Provides the standard 2-input MWArray interface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axes1">Input argument #1</param>
    /// <param name="axes2">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotIteration(int numArgsOut, MWArray axes1, MWArray axes2)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotIteration", axes1, axes2);
    }


    /// <summary>
    /// Provides the standard 3-input MWArray interface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axes1">Input argument #1</param>
    /// <param name="axes2">Input argument #2</param>
    /// <param name="db1">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotIteration(int numArgsOut, MWArray axes1, MWArray axes2, MWArray 
                             db1)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotIteration", axes1, axes2, db1);
    }


    /// <summary>
    /// Provides the standard 4-input MWArray interface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axes1">Input argument #1</param>
    /// <param name="axes2">Input argument #2</param>
    /// <param name="db1">Input argument #3</param>
    /// <param name="db2">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotIteration(int numArgsOut, MWArray axes1, MWArray axes2, MWArray 
                             db1, MWArray db2)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotIteration", axes1, axes2, db1, db2);
    }


    /// <summary>
    /// Provides the standard 5-input MWArray interface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axes1">Input argument #1</param>
    /// <param name="axes2">Input argument #2</param>
    /// <param name="db1">Input argument #3</param>
    /// <param name="db2">Input argument #4</param>
    /// <param name="radius">Input argument #5</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotIteration(int numArgsOut, MWArray axes1, MWArray axes2, MWArray 
                             db1, MWArray db2, MWArray radius)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotIteration", axes1, axes2, db1, db2, radius);
    }


    /// <summary>
    /// Provides the standard 6-input MWArray interface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axes1">Input argument #1</param>
    /// <param name="axes2">Input argument #2</param>
    /// <param name="db1">Input argument #3</param>
    /// <param name="db2">Input argument #4</param>
    /// <param name="radius">Input argument #5</param>
    /// <param name="varargin">Array of MWArrays representing the input arguments 6
    /// through varargin.length+5</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotIteration(int numArgsOut, MWArray axes1, MWArray axes2, MWArray 
                             db1, MWArray db2, MWArray radius, params MWArray[] varargin)
    {
      MWArray[] args = {axes1, axes2, db1, db2, radius};
      int nonVarargInputNum = args.Length;
      int varargInputNum = varargin.Length;
      int totalNumArgs = varargInputNum > 0 ? (nonVarargInputNum + varargInputNum) : nonVarargInputNum;
      Array newArr = Array.CreateInstance(typeof(MWArray), totalNumArgs);

      int idx = 0;

      for (idx = 0; idx < nonVarargInputNum; idx++)
        newArr.SetValue(args[idx],idx);

      if (varargInputNum > 0)
      {
        for (int i = 0; i < varargInputNum; i++)
        {
          newArr.SetValue(varargin[i], idx);
          idx++;
        }
      }

      return mcr.EvaluateFunction(numArgsOut, "PlotIteration", (MWArray[])newArr );
    }


    /// <summary>
    /// Provides a void output, 0-input MWArrayinterface to the PlotLine MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void PlotLine()
    {
      mcr.EvaluateFunction(0, "PlotLine", new MWArray[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input MWArrayinterface to the PlotLine MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx1">Input argument #1</param>
    ///
    public void PlotLine(MWArray posx1)
    {
      mcr.EvaluateFunction(0, "PlotLine", posx1);
    }


    /// <summary>
    /// Provides a void output, 2-input MWArrayinterface to the PlotLine MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx1">Input argument #1</param>
    /// <param name="posy1">Input argument #2</param>
    ///
    public void PlotLine(MWArray posx1, MWArray posy1)
    {
      mcr.EvaluateFunction(0, "PlotLine", posx1, posy1);
    }


    /// <summary>
    /// Provides a void output, 3-input MWArrayinterface to the PlotLine MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx1">Input argument #1</param>
    /// <param name="posy1">Input argument #2</param>
    /// <param name="posx2">Input argument #3</param>
    ///
    public void PlotLine(MWArray posx1, MWArray posy1, MWArray posx2)
    {
      mcr.EvaluateFunction(0, "PlotLine", posx1, posy1, posx2);
    }


    /// <summary>
    /// Provides a void output, 4-input MWArrayinterface to the PlotLine MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx1">Input argument #1</param>
    /// <param name="posy1">Input argument #2</param>
    /// <param name="posx2">Input argument #3</param>
    /// <param name="posy2">Input argument #4</param>
    ///
    public void PlotLine(MWArray posx1, MWArray posy1, MWArray posx2, MWArray posy2)
    {
      mcr.EvaluateFunction(0, "PlotLine", posx1, posy1, posx2, posy2);
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the PlotLine MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotLine(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotLine", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the PlotLine MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx1">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotLine(int numArgsOut, MWArray posx1)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotLine", posx1);
    }


    /// <summary>
    /// Provides the standard 2-input MWArray interface to the PlotLine MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx1">Input argument #1</param>
    /// <param name="posy1">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotLine(int numArgsOut, MWArray posx1, MWArray posy1)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotLine", posx1, posy1);
    }


    /// <summary>
    /// Provides the standard 3-input MWArray interface to the PlotLine MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx1">Input argument #1</param>
    /// <param name="posy1">Input argument #2</param>
    /// <param name="posx2">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotLine(int numArgsOut, MWArray posx1, MWArray posy1, MWArray posx2)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotLine", posx1, posy1, posx2);
    }


    /// <summary>
    /// Provides the standard 4-input MWArray interface to the PlotLine MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx1">Input argument #1</param>
    /// <param name="posy1">Input argument #2</param>
    /// <param name="posx2">Input argument #3</param>
    /// <param name="posy2">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotLine(int numArgsOut, MWArray posx1, MWArray posy1, MWArray 
                        posx2, MWArray posy2)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotLine", posx1, posy1, posx2, posy2);
    }


    /// <summary>
    /// Provides a void output, 0-input MWArrayinterface to the PlotNameCircle MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void PlotNameCircle()
    {
      mcr.EvaluateFunction(0, "PlotNameCircle", new MWArray[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input MWArrayinterface to the PlotNameCircle MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx">Input argument #1</param>
    ///
    public void PlotNameCircle(MWArray posx)
    {
      mcr.EvaluateFunction(0, "PlotNameCircle", posx);
    }


    /// <summary>
    /// Provides a void output, 2-input MWArrayinterface to the PlotNameCircle MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    ///
    public void PlotNameCircle(MWArray posx, MWArray posy)
    {
      mcr.EvaluateFunction(0, "PlotNameCircle", posx, posy);
    }


    /// <summary>
    /// Provides a void output, 3-input MWArrayinterface to the PlotNameCircle MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <param name="string0">Input argument #3</param>
    ///
    public void PlotNameCircle(MWArray posx, MWArray posy, MWArray string0)
    {
      mcr.EvaluateFunction(0, "PlotNameCircle", posx, posy, string0);
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the PlotNameCircle MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotNameCircle(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotNameCircle", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the PlotNameCircle MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotNameCircle(int numArgsOut, MWArray posx)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotNameCircle", posx);
    }


    /// <summary>
    /// Provides the standard 2-input MWArray interface to the PlotNameCircle MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotNameCircle(int numArgsOut, MWArray posx, MWArray posy)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotNameCircle", posx, posy);
    }


    /// <summary>
    /// Provides the standard 3-input MWArray interface to the PlotNameCircle MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <param name="string0">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotNameCircle(int numArgsOut, MWArray posx, MWArray posy, MWArray 
                              string0)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotNameCircle", posx, posy, string0);
    }


    /// <summary>
    /// Provides a void output, 0-input MWArrayinterface to the PlotTraficLight MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void PlotTraficLight()
    {
      mcr.EvaluateFunction(0, "PlotTraficLight", new MWArray[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input MWArrayinterface to the PlotTraficLight MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    ///
    public void PlotTraficLight(MWArray axeshandle)
    {
      mcr.EvaluateFunction(0, "PlotTraficLight", axeshandle);
    }


    /// <summary>
    /// Provides a void output, 2-input MWArrayinterface to the PlotTraficLight MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    ///
    public void PlotTraficLight(MWArray axeshandle, MWArray posx)
    {
      mcr.EvaluateFunction(0, "PlotTraficLight", axeshandle, posx);
    }


    /// <summary>
    /// Provides a void output, 3-input MWArrayinterface to the PlotTraficLight MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <param name="posy">Input argument #3</param>
    ///
    public void PlotTraficLight(MWArray axeshandle, MWArray posx, MWArray posy)
    {
      mcr.EvaluateFunction(0, "PlotTraficLight", axeshandle, posx, posy);
    }


    /// <summary>
    /// Provides a void output, 4-input MWArrayinterface to the PlotTraficLight MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <param name="posy">Input argument #3</param>
    /// <param name="color">Input argument #4</param>
    ///
    public void PlotTraficLight(MWArray axeshandle, MWArray posx, MWArray posy, MWArray 
                          color)
    {
      mcr.EvaluateFunction(0, "PlotTraficLight", axeshandle, posx, posy, color);
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the PlotTraficLight MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotTraficLight(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotTraficLight", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the PlotTraficLight MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotTraficLight(int numArgsOut, MWArray axeshandle)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotTraficLight", axeshandle);
    }


    /// <summary>
    /// Provides the standard 2-input MWArray interface to the PlotTraficLight MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotTraficLight(int numArgsOut, MWArray axeshandle, MWArray posx)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotTraficLight", axeshandle, posx);
    }


    /// <summary>
    /// Provides the standard 3-input MWArray interface to the PlotTraficLight MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <param name="posy">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotTraficLight(int numArgsOut, MWArray axeshandle, MWArray posx, 
                               MWArray posy)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotTraficLight", axeshandle, posx, posy);
    }


    /// <summary>
    /// Provides the standard 4-input MWArray interface to the PlotTraficLight MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <param name="posy">Input argument #3</param>
    /// <param name="color">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] PlotTraficLight(int numArgsOut, MWArray axeshandle, MWArray posx, 
                               MWArray posy, MWArray color)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotTraficLight", axeshandle, posx, posy, color);
    }



    /// <summary>
    /// This method will cause a MATLAB figure window to behave as a modal dialog box.
    /// The method will not return until all the figure windows associated with this
    /// component have been closed.
    /// </summary>
    /// <remarks>
    /// An application should only call this method when required to keep the
    /// MATLAB figure window from disappearing.  Other techniques, such as calling
    /// Console.ReadLine() from the application should be considered where
    /// possible.</remarks>
    ///
    public void WaitForFiguresToDie()
    {
      mcr.WaitForFiguresToDie();
    }



    #endregion Methods

    #region Class Members

    private static MWMCR mcr= null;

    private static Exception ex_= null;

    private bool disposed= false;

    #endregion Class Members
  }
}
